﻿//*******************************************************************************************************
//*																										*
//*		文件：D3D9ZhongWen.h																			*
//*																										*
//*		说明：对d3d9.h进行汉化。																		*
//*			  使用该汉化可能会导致程序效率变低。														*
//*																										*
//*		拓展：您可访问，并且强烈推荐您访问Micorsoft官方文档。											*
//*			  以获取更详细的解说及演示代码。															*
//*			  https://learn.microsoft.com/zh-cn/windows/win32/direct3d9/dx9-graphics-reference-d3d		*
//*																										*
//*******************************************************************************************************
#include "default.h"
#include "D3D9TypesZhongWen.h"
#include "D3D9CapsZhongWen.h"

#ifndef _D3D9ZHONGWEN_H_ABCDE_
#define _D3D9ZHONGWEN_H_ABCDE_

//此二项受D3D_DEBUG_INFO影响，可能会导致其值不同。
#define D3D_开发包版本号    D3D_SDK_VERSION
#define D3D9b_开发包版本号  D3D9b_SDK_VERSION

// ======================
// D3D9接口前向定义
// ======================
template<typename T原生接口, typename T关联设备接口>
class _通用基类;

template<typename T原生接口>
class _显卡管理器基类;
//typedef _显卡管理器基类<IDirect3D9> 显卡管理器;

template<typename T原生接口, typename T关联设备接口>
class _显卡设备基类;
//typedef _显卡设备基类<IDirect3DDevice9, 显卡管理器> 显卡设备;

template<typename T关联设备接口>
class _状态块;

template<typename T原生接口, typename T关联设备接口>
class _交换链基类;
//typedef _交换链基类<IDirect3DSwapChain9, 显卡设备> 交换链;

template<typename T原生接口, typename T关联设备接口>
class _图形资源;

template<typename T关联设备接口>
class _顶点格式声明;
template<typename T关联设备接口>
class _顶点着色器;
template<typename T关联设备接口>
class _像素着色器;

template<typename T原生接口, typename T关联设备接口>
class _基础纹理;
template<typename T关联设备接口>
class _平面纹理;
template<typename T关联设备接口>
class _体积纹理;
template<typename T关联设备接口>
class _立方体贴图;
template<typename T关联设备接口>
class _顶点缓冲区;
template<typename T关联设备接口>
class _索引缓冲区;
template<typename T所属容器接口, typename T关联设备接口>
class _显存表面;
template<typename T所属容器接口, typename T关联设备接口>
class _三维体积;
template<typename T关联设备接口>
class _状态查询器;

// ======================
// D3D9Ex扩展接口前向定义
// ======================
#if !defined(D3D_DISABLE_9EX)

class 显卡管理器Ex;
class 显卡设备Ex;
class 交换链Ex;
class 覆盖层;
class 视频设备;
class 认证通道;
class 加密会话;

#endif

// ======================
// 核心接口封装
// ======================

template<typename T原生接口, typename T关联设备接口>
class _通用基类
{
protected:
	T原生接口* m_p原生接口;
	T关联设备接口* m_p关联设备;

public:
	//explicit 
	_通用基类<typename T原生接口, typename T关联设备接口>(T原生接口* p原生, T关联设备接口* p设备)
		: m_p原生接口(p原生), m_p关联设备(p设备){}
	~_通用基类<typename T原生接口, typename T关联设备接口>(){}
	// --------------------------
    // IUnknown 方法
    // --------------------------
    HRESULT 查询接口(REFIID 接口标识, void** 输出接口);

    UINT 增加引用();
    // 任何封装类都不应使用析构函数调用 释放资源()。
    // 因为在析构函数中调用可能在某些情况下意外释放资源。
    // 请在需要释放资源时手动调用 释放资源()。
    UINT 释放资源();

	// --------------------------
    // 通用方法
    // --------------------------

	// 获取关联的显卡/管理器设备
    T关联设备接口* 获取关联设备();

    //作为临时措施，获取原生接口
    // 警告：
    //  此方法仅用于DX9中文封装库内部使用。
    //  在部分函数需求原生接口时调用。
    //  请不要在程序中使用此方法。
    //  此方法可能会在未来的版本中被删除。
    T原生接口* ⚠获取原生指针();
};

template<typename T原生接口>
class _显卡管理器基类 : public _通用基类<T原生接口, void> // IDirect3D9
{
private:
	using _通用基类<T原生接口, void>::获取关联设备;
	
protected:
	using _通用基类<T原生接口, void>::m_p原生接口;

public:
	_显卡管理器基类(): _通用基类<T原生接口, void>(nullptr, nullptr){}
	~_显卡管理器基类(){}
	bool 初始化(UINT SDK版本);

    // --------------------------
    // 核心功能方法
    // --------------------------
    HRESULT 注册软件设备(void* 初始化函数指针);

    UINT 获取显卡数量()const;

    HRESULT 获取显卡标识(
        UINT 显卡索引, 
        DWORD 标志, 
        显卡信息* 输出信息
   );

    UINT 获取显示模式数量(
        UINT 显卡索引 , 
        像素格式 格式
   )const;

    HRESULT 枚举显示模式(
        UINT 显卡索引, 
        像素格式 格式, 
        UINT 模式索引, 
        显示模式* 输出模式
   );

    HRESULT 获取当前显示模式(
        UINT 显卡索引, 
        显示模式* 输出模式
   );

    HRESULT 检查设备类型兼容性(
        UINT 显卡索引, 
        设备类型 设备类型, 
        像素格式 显卡格式, 
        像素格式 后台缓冲格式, 
        BOOL 窗口化模式
   );

    HRESULT 检查设备格式支持(
        UINT 显卡索引, 
        设备类型 设备类型, 
        像素格式 显卡格式, 
        DWORD 用途标志, 
        资源类型 资源类型, 
        像素格式 检查格式
   );

    HRESULT 检查多重采样支持(
        UINT 显卡索引, 
        设备类型 设备类型, 
        像素格式 表面格式, 
        BOOL 窗口化模式, 
        多重采样类型 采样类型, 
        DWORD* 输出质量等级
   );

    HRESULT 检查深度模板匹配(
        UINT 显卡索引, 
        设备类型 设备类型, 
        像素格式 显卡格式, 
        像素格式 渲染目标格式, 
        像素格式 深度模板格式
   );

    HRESULT 检查格式转换支持(
        UINT 显卡索引, 
        设备类型 设备类型, 
        像素格式 源格式, 
        像素格式 目标格式
   );

    HRESULT 获取设备能力(
        UINT 显卡索引, 
        设备类型 设备类型, 
        设备能力* 输出能力描述
   );

    HMONITOR 获取显卡显示器(
        UINT 显卡索引
   )const;

    HRESULT 创建设备(
        UINT 显卡索引, 
        设备类型 设备类型, 
        HWND 焦点窗口, 
        DWORD 行为标志, 
        呈现参数* 呈现参数, 
        _显卡设备基类<IDirect3DDevice9, _显卡管理器基类<T原生接口>>** 输出设备
   );

	#ifdef D3D_DEBUG_INFO
		// 调试版本专用
		LPCWSTR 版本信息; // 原始Version字段
	#endif
};

template<typename T原生接口, typename T关联设备接口>
class _显卡设备基类:public _通用基类<T原生接口, T关联设备接口> // IDirect3DDevice9
{
protected:
	using _通用基类<T原生接口, T关联设备接口>::m_p原生接口;
	using _通用基类<T原生接口, T关联设备接口>::m_p关联设备;
	void* m_p绑定纹理;
public:
	_显卡设备基类(T原生接口* p原生, T关联设备接口* p关联设备): _通用基类<T原生接口, T关联设备接口>(p原生, p关联设备){}
	~_显卡设备基类(){}
	// bool 初始化⚠(IDirect3DDevice9* pDevice)

	// -------------------------------
    // 设备状态管理
    // -------------------------------
    
    // 检测设备协作级别（用于丢失设备恢复）
    HRESULT 检测设备状态();

    // 获取当前可用纹理内存（单位：字节）
    UINT 获取可用显存()const;

    // 强制释放托管资源
    HRESULT 释放托管资源();

    // -------------------------------
    // 设备信息获取
    // -------------------------------

    // 获取设备能力描述
    HRESULT 获取设备能力(设备能力* 能力描述);

    // -------------------------------
    // 显示模式管理
    // -------------------------------

    // 获取指定交换链的显示模式
    HRESULT 获取显示模式(UINT 交换链索引, 显示模式* 显示模式);

    // 获取设备创建参数
    HRESULT 获取创建参数(设备创建参数* 创建参数);

    // -------------------------------
    // 光标控制
    // -------------------------------

    // 设置光标属性
    HRESULT 设置光标属性(
        UINT x, 
        UINT y, 
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 光标位图
   );

    // 设置光标位置
    void 设置光标位置(UINT x, UINT y, DWORD 标志);

    // 显示/隐藏光标
    BOOL 显示光标(BOOL 是否显示);

    // -------------------------------
    // 交换链管理
    // -------------------------------

    // 创建额外交换链
    HRESULT 创建额外交换链(
        呈现参数* 呈现参数, 
        _交换链基类<IDirect3DSwapChain9, _显卡设备基类<T原生接口, T关联设备接口>>** pp交换链
   );

    // 获取指定交换链
    HRESULT 获取交换链(UINT 交换链索引, _交换链基类<IDirect3DSwapChain9, _显卡设备基类<T原生接口, T关联设备接口>>** pp交换链);

    // 获取交换链总数
    UINT 获取交换链数量()const;

    // -------------------------------
    // 设备重置与呈现
    // -------------------------------

    // 重置图形设备
    HRESULT 重置设备(呈现参数* 新呈现参数);

    // 提交画面呈现
    HRESULT 呈现画面(
        const RECT* 源区域, 
        const RECT* 目标区域, 
        HWND 目标窗口, 
        const RGNDATA* 脏区域
   );

	// -------------------------------
    // 交换链与显示控制
    // -------------------------------
    
    // 获取交换链的后台缓冲区
    HRESULT 获取后台缓冲区(
        UINT 交换链索引,
        UINT 缓冲区索引,
        后台缓冲类型 缓冲类型,
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面
   );

    // 获取光栅器状态
    HRESULT 获取光栅状态(
        UINT 交换链索引,
        光栅状态* 输出状态
   );

    // 启用/禁用对话框模式（用于GDI兼容）
    HRESULT 设置对话框模式(BOOL 启用对话框);

    // -------------------------------
    // 伽马校正
    // -------------------------------
    
    // 设置伽马表
    void 设置伽马表(
        UINT 交换链索引,
        DWORD 标志,
        const 伽马斜坡* 伽马数据
   );

    // 获取当前伽马表
    void 获取伽马表(
        UINT 交换链索引,
        伽马斜坡* 输出伽马数据
   );

    // -------------------------------
    // 资源创建（基础封装）
    // -------------------------------
    
    // 创建_平面纹理
    HRESULT 创建纹理(
        UINT 宽度,
        UINT 高度,
        UINT Mip层级,
        DWORD 用途,
        像素格式 格式,
        资源池类型 存储池,
        _平面纹理<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出纹理,
        HANDLE* 共享句柄 = nullptr
   );

    // 创建体积纹理
    HRESULT 创建体积纹理(
        UINT 宽度,
        UINT 高度,
        UINT 深度,
        UINT Mip层级,
        DWORD 用途,
        像素格式 格式,
        资源池类型 存储池,
        _体积纹理<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出纹理,
        HANDLE* 共享句柄 = nullptr
   );

    // 创建立方体贴图
    HRESULT 创建立方体贴图(
        UINT 边长,
        UINT Mip层级,
        DWORD 用途,
        像素格式 格式,
        资源池类型 存储池,
        _立方体贴图<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出纹理,
        HANDLE* 共享句柄 = nullptr
   );

    // 创建顶点缓冲区
    HRESULT 创建顶点缓冲区(
        UINT 数据大小,
        DWORD 用途,
        DWORD FVF格式,
        资源池类型 存储池,
        _顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出缓冲区,
        HANDLE* 共享句柄 = nullptr
   );

    // 创建索引缓冲区
    HRESULT 创建索引缓冲区(
        UINT 数据大小,
        DWORD 用途,
        像素格式 格式,
        资源池类型 存储池,
        _索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出缓冲区,
        HANDLE* 共享句柄 = nullptr
   );

    // -------------------------------
    // 渲染目标与表面操作
    // -------------------------------
    
    // 创建渲染目标表面
    HRESULT 创建渲染目标(
        UINT 宽度,
        UINT 高度,
        像素格式 格式,
        多重采样类型 采样类型,
        DWORD 采样质量,
        BOOL 锁定表面,
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面,
        HANDLE* 共享句柄 = nullptr
   );

    // 创建深度模板表面
    HRESULT 创建深度模板表面(
        UINT 宽度,
        UINT 高度,
        像素格式 格式,
        多重采样类型 采样类型,
        DWORD 采样质量,
        BOOL 自动丢弃,
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面,
        HANDLE* 共享句柄 = nullptr
   );

    // -------------------------------
    // 数据更新操作
    // -------------------------------
    
    // 更新表面数据
    HRESULT 更新表面数据(
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 源表面,
        const RECT* 源区域,
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 目标表面,
        const POINT* 目标位置
   );

    // 更新纹理数据
	template<typename T纹理接口>
    HRESULT 更新纹理数据(
        T纹理接口* 源纹理,
        T纹理接口* 目标纹理
   );

    // 获取渲染目标数据
    HRESULT 获取渲染目标数据(
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 渲染目标,
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 目标表面
   );

	// -------------------------------
    // 表面操作与截图
    // -------------------------------
    
    // 获取前台缓冲区数据（截屏功能）
    HRESULT 获取前台缓冲数据(
        UINT 交换链索引, 
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面
   );

    // 表面区域拉伸复制
    HRESULT 拉伸复制表面区域(
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 源表面,
        const RECT* 源区域,
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 目标表面,
        const RECT* 目标区域,
        纹理过滤方式 过滤方式
   );

    // 填充表面颜色
    HRESULT 填充颜色(
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 目标表面,
        const RECT* 填充区域,
        颜色值 颜色
   );

    // 创建离屏表面
    HRESULT 创建离屏表面(
        UINT 宽度,
        UINT 高度,
        像素格式 格式,
        资源池类型 存储池,
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面,
        HANDLE* 共享句柄 = nullptr
   );

    // -------------------------------
    // 渲染目标管理
    // -------------------------------
    
    // 设置渲染目标表面
    HRESULT 设置渲染目标(
        DWORD 目标索引,
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 渲染目标
   );

    // 获取当前渲染目标
    HRESULT 获取渲染目标(
        DWORD 目标索引,
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面
   );

    // 设置深度模板表面
    HRESULT 设置深度模板表面(
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>* 深度模板
   );

    // 获取当前深度模板表面
    HRESULT 获取深度模板表面(
        _显存表面<void, _显卡设备基类<T原生接口, T关联设备接口>>** pp输出表面
   );

    // -------------------------------
    // 场景控制
    // -------------------------------
    
    // 开始渲染场景
    HRESULT 开始渲染();

    // 结束渲染场景
    HRESULT 结束渲染();

    // 清空缓冲区
    HRESULT 清空缓冲区(
        DWORD 区域数量,
        const D3DRECT* 清空区域数组,
        DWORD 清空标志,
        颜色值 清空颜色,
        float 深度值,
        DWORD 模板值
   );

    // -------------------------------
    // 坐标变换管理
    // -------------------------------
    
    // 设置变换矩阵
    HRESULT 设置变换矩阵(
        变换矩阵 矩阵类型,
        const 矩阵* 矩阵
   );

    // 获取变换矩阵
    HRESULT 获取变换矩阵(
        变换矩阵 矩阵类型,
        矩阵* 输出矩阵
   );

    // 矩阵乘法变换
    HRESULT 级联变换矩阵(
        变换矩阵 矩阵类型,
        const 矩阵* 变换矩阵
   );

    // -------------------------------
    // 视口设置
    // -------------------------------
    
    // 设置渲染视口
    HRESULT 设置视口参数(
        const 视口参数* 视口参数
   );

	// -------------------------------
    // 视口与材质管理
    // -------------------------------
    
    // 获取当前视口参数
    HRESULT 获取视口参数(视口参数* 输出参数);

    // 设置材质属性
    HRESULT 设置材质属性(const 材质* 材质数据);

    // 获取当前材质属性
    HRESULT 获取材质属性(材质* 输出材质);

    // -------------------------------
    // 光照系统管理
    // -------------------------------
    
    // 设置光源参数
    HRESULT 设置光源属性(
        DWORD 光源索引, 
        const 光源* 光源参数
   );

    // 获取光源参数
    HRESULT 获取光源属性(
        DWORD 光源索引,
        光源* 输出参数
   );

    // 启用/禁用光源
    HRESULT 开关光源(
        DWORD 光源索引, 
        BOOL 是否启用
   );

    // 查询光源状态
    HRESULT 获取光源状态(
        DWORD 光源索引, 
        BOOL* 输出启用状态
   );

    // -------------------------------
    // 裁剪平面设置
    // -------------------------------
    
    // 设置裁剪平面方程
    HRESULT 设置裁剪平面(
        DWORD 平面索引, 
        const float* 平面方程
   );

    // 获取裁剪平面参数
    HRESULT 获取裁剪平面(
        DWORD 平面索引, 
        float* 输出方程
   );

    // -------------------------------
    // 渲染状态管理
    // -------------------------------
    
    // 设置渲染状态
    HRESULT 设置渲染状态(
        渲染状态 状态类型, 
        DWORD 状态值
   );

    // 获取当前渲染状态
    HRESULT 获取渲染状态(
        渲染状态 状态类型, 
        DWORD* 输出状态值
   );

    // -------------------------------
    // _状态块管理
    // -------------------------------
    
    // 创建状态块
    HRESULT 创建状态块(
        状态块类型 类型, 
        _状态块<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出状态块
   );

    // 开始记录状态块
    HRESULT 开始记录状态块();

    // 结束记录并返回状态块
    HRESULT 结束记录状态块(_状态块<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出状态块);

    // -------------------------------
    // 裁剪状态设置
    // -------------------------------
    
    // 设置裁剪状态
    HRESULT 设置裁剪状态(const 裁剪状态* 状态参数);

	// -------------------------------
    // 裁剪状态获取
    // -------------------------------
    HRESULT 获取裁剪状态(裁剪状态* 输出状态);

    // -------------------------------
    // 纹理管理
    // -------------------------------
	template<typename T纹理接口>
    HRESULT 获取绑定纹理(DWORD 纹理阶段, T纹理接口** pp输出纹理);
	template<typename T纹理接口>
    HRESULT 绑定纹理(DWORD 纹理阶段, T纹理接口* 纹理);

    // -------------------------------
    // 纹理阶段状态
    // -------------------------------
    HRESULT 获取纹理阶段状态(
        DWORD 纹理阶段,
        纹理阶段状态 状态类型,
        DWORD* 输出状态值
   );

    HRESULT 设置纹理阶段状态(
        DWORD 纹理阶段,
        纹理阶段状态 状态类型,
        DWORD 状态值
   );

    // -------------------------------
    // 采样器状态
    // -------------------------------
    HRESULT 获取采样器状态(
        DWORD 采样器索引,
        采样器状态 状态类型,
        DWORD* 输出状态值
   );

    HRESULT 设置采样器状态(
        DWORD 采样器索引,
        采样器状态 状态类型,
        DWORD 状态值
   );

    // -------------------------------
    // 设备验证
    // -------------------------------
    HRESULT 验证设备支持(DWORD* 输出所需渲染次数);

    // -------------------------------
    // 调色板管理
    // -------------------------------
    HRESULT 设置调色板颜色项(
        UINT 调色板编号,
        const PALETTEENTRY* 颜色数组 //WinGDI调色板
   );

    HRESULT 获取调色板颜色项(
        UINT 调色板编号,
        PALETTEENTRY* 输出颜色数组
   );

    HRESULT 激活调色板(UINT 调色板编号);

    HRESULT 获取当前调色板(UINT* 输出调色板编号);

    // -------------------------------
    // 裁剪区域控制
    // -------------------------------
    HRESULT 设置裁剪区域(const RECT* 裁剪区域);

    HRESULT 获取裁剪区域(RECT* 输出区域);

    // -------------------------------
    // 顶点处理模式
    // -------------------------------
    HRESULT 设置软件顶点处理(BOOL 启用软件处理);

	// -------------------------------
    // 顶点处理模式查询
    // -------------------------------
    BOOL 是否使用软件顶点处理()const;

    // -------------------------------
    // N-Patch曲面细分
    // -------------------------------
    HRESULT 设置NURBS细分级别(float 细分段数);

    float 获取当前细分级别()const;

    // -------------------------------
    // 基本绘制指令
    // -------------------------------
    HRESULT 绘制图元(
        图元 类型,
        UINT 起始顶点索引,
        UINT 图元数量
   );

    HRESULT 绘制索引图元(
        图元 类型,
        INT 基准顶点偏移,
        UINT 最小顶点索引,
        UINT 使用顶点数,
        UINT 起始索引,
        UINT 图元数量
   );

    // -------------------------------
    // UP（用户指针）绘制模式
    // -------------------------------
    HRESULT 快速绘制图元(
        图元 类型,
        UINT 图元数量,
        const void* 顶点数据指针,
        UINT 顶点步长
   );

    HRESULT 快速绘制索引图元(
        图元 类型,
        UINT 最小顶点索引,
        UINT 使用顶点数,
        UINT 图元数量,
        const void* 索引数据指针,
        像素格式 格式,
        const void* 顶点数据指针,
        UINT 顶点步长
   );

    // -------------------------------
    // 顶点处理与声明
    // -------------------------------
    HRESULT 处理顶点数据(
        UINT 源起始索引,
        UINT 目标索引,
        UINT 顶点数量,
        _顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 目标缓冲区,
        _顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>* 声明接口,
        DWORD 处理标志
   );

    HRESULT 创建顶点声明(
        const 顶点元素定义* 元素数组,
        _顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出声明
   );

    HRESULT 绑定顶点声明(_顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>* 声明接口);

    HRESULT 获取当前顶点声明(_顶点格式声明<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出声明);

    // -------------------------------
    // FVF灵活顶点格式
    // -------------------------------
    HRESULT 设置FVF格式(DWORD FVF标志);

    HRESULT 获取当前FVF格式(DWORD* 输出标志);

    // -------------------------------
    // _顶点着色器管理
    // -------------------------------
    HRESULT 创建顶点着色器(
        const DWORD* 着色器字节码,
        _顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出着色器
   );

    HRESULT 绑定顶点着色器(_顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>* 着色器);

    HRESULT 获取当前顶点着色器(_顶点着色器<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出着色器);

	// ========================
    // _顶点着色器常量管理
    // ========================
    
    // 设置浮点常量数组
    HRESULT 设置顶点着色器浮点常量(
        UINT 起始寄存器,
        const float* 常量数据,
        UINT 四维向量数量
   );

    // 获取浮点常量数组
    HRESULT 获取顶点着色器浮点常量(
        UINT 起始寄存器,
        float* 输出数据,
        UINT 四维向量数量
   );

    // 设置整型常量数组
    HRESULT 设置顶点着色器整型常量(
        UINT 起始寄存器,
        const int* 常量数据,
        UINT 四维向量数量
   );

    // 获取整型常量数组
    HRESULT 获取顶点着色器整型常量(
        UINT 起始寄存器,
        int* 输出数据,
        UINT 四维向量数量
   );

    // 设置布尔常量
    HRESULT 设置顶点着色器布尔常量(
        UINT 起始寄存器,
        const BOOL* 常量数据,
        UINT 布尔数量
   );

    // 获取布尔常量
    HRESULT 获取顶点着色器布尔常量(
        UINT 起始寄存器,
        BOOL* 输出数据,
        UINT 布尔数量
   );

    // ========================
    // 顶点流管理
    // ========================
    
    // 绑定顶点流源
    HRESULT 设置顶点流源(
        UINT 流编号,
        _顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 流数据,
        UINT 字节偏移量,
        UINT 顶点步长
   );

    // 获取当前顶点流设置
    HRESULT 获取顶点流源(
        UINT 流编号,
        _顶点缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出流数据,
        UINT* 输出偏移量,
        UINT* 输出步长
   );

    // 设置顶点流频率
    HRESULT 设置顶点流频率(
        UINT 流编号,
        UINT 频率设置
   );

    // 获取顶点流频率
    HRESULT 获取顶点流频率(
        UINT 流编号,
        UINT* 输出频率
   );

    // ========================
    // 索引缓冲管理
    // ========================
    
    // 绑定索引缓冲
    HRESULT 设置索引缓冲(
        _索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>* 索引数据
   );

    // 获取当前索引缓冲
    HRESULT 获取索引缓冲(
        _索引缓冲区<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出索引数据
   );

    // ========================
    // _像素着色器管理
    // ========================
    
    // 创建_像素着色器
    HRESULT 创建像素着色器(
        const DWORD* 着色器字节码,
        _像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出着色器
   );

    // 绑定_像素着色器
    HRESULT 设置像素着色器(
        _像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>* 着色器
   );

    // ========================
    // _像素着色器管理
    // ========================
    HRESULT 获取当前像素着色器(_像素着色器<_显卡设备基类<T原生接口, T关联设备接口>>** 输出着色器);

    // ========================
    // _像素着色器常量管理
    // ========================
    HRESULT 设置像素着色器浮点常量(
        UINT 起始寄存器,
        const float* 常量数据,
        UINT 四维向量数量
   );

    HRESULT 获取像素着色器浮点常量(
        UINT 起始寄存器,
        float* 输出数据,
        UINT 四维向量数量
   );

    HRESULT 设置像素着色器整型常量(
        UINT 起始寄存器,
        const int* 常量数据,
        UINT 四维向量数量
   );

    HRESULT 获取像素着色器整型常量(
        UINT 起始寄存器,
        int* 输出数据,
        UINT 四维向量数量
   );

    HRESULT 设置像素着色器布尔常量(
        UINT 起始寄存器,
        const BOOL* 常量数据,
        UINT 布尔数量
   );

    HRESULT 获取像素着色器布尔常量(
        UINT 起始寄存器,
        BOOL* 输出数据,
        UINT 布尔数量
   );

    // ========================
    // 高阶曲面补丁绘制
    // ========================
    HRESULT 绘制矩形面片(
        UINT 面片句柄,
        const float* 细分段数,
        const 矩形面片信息* 面片信息
   );

    HRESULT 绘制三角面片(
        UINT 面片句柄,
        const float* 细分段数,
        const 三角面片信息* 面片信息
   );

    HRESULT 删除面片(UINT 面片句柄);

    // ========================
    // 查询对象管理
    // ========================
    HRESULT 创建查询对象(
        查询类型 类型,
        _状态查询器<_显卡设备基类<T原生接口, T关联设备接口>>** pp输出查询
   );

	#ifdef D3D_DEBUG_INFO
    // ========================
    // 调试信息区（仅调试版本可见）
    // ========================

    // 注意：当前版本没有完成这个函数的实现，请暂时不要使用该函数。
    // 同步信息，用于将原生对象接口的调试信息同步至汉化调试信息。
    // 需要查询调试信息时先调用。
    // 注意：不会在原生对象的调试信息变更时自动更新，
    // 所以每次查询调试信息前都需要调用此方法。
    void 同步调试信息();

    // 设备创建参数
    设备创建参数 创建参数;

    // 呈现参数配置
    呈现参数 当前呈现参数;

    // 显示模式信息
    显示模式 当前显示模式;

    // 硬件能力描述
    设备能力 设备能力描述;

    // 资源统计
    UINT 可用显存字节数;         // 原始AvailableTextureMem
    UINT 活动交换链数量;         // 原始SwapChains
    UINT 绑定纹理数量;           // 原始Textures
    UINT _顶点缓冲区数量;         // 原始VertexBuffers
    UINT _索引缓冲区数量;         // 原始IndexBuffers
    UINT _顶点着色器数量;         // 原始VertexShaders
    UINT _像素着色器数量;         // 原始PixelShaders

    // 渲染状态快照
    视口参数 当前视口;
    矩阵 投影矩阵;
    矩阵 观察矩阵;
    矩阵 世界矩阵;
    矩阵 纹理矩阵组[8]; // 8个纹理坐标变换矩阵

    // 顶点处理状态
    DWORD 当前灵活顶点格式;       // 原始FVF
    UINT 顶点数据步长;           // 原始VertexSize
    DWORD _顶点着色器版本号;       // 原始VertexShaderVersion
    DWORD _像素着色器版本号;       // 原始PixelShaderVersion
    BOOL 软件顶点处理模式;        // 原始SoftwareVertexProcessing

    // 材质与光照
    材质 当前材质;
    光源 光源配置组[16];     // 16个光源配置
    BOOL 光源启用状态[16];        // 各光源开关状态

    // 显示设置
    伽马斜坡 当前伽马表;
    RECT 当前裁剪区域;           // 原始ScissorRect
    BOOL 对话框模式已启用;        // 原始DialogBoxMode
	#endif
};

template<typename T关联设备接口>
class _状态块:public _通用基类<IDirect3DStateBlock9, T关联设备接口> // IDirect3DStateBlock9
{
public:
    // --------------------------
    // 基础接口方法
    // --------------------------
	_状态块(IDirect3DStateBlock9* p原生, T关联设备接口* p显卡):_通用基类<IDirect3DStateBlock9, T关联设备接口>(p原生, p显卡){}
    ~_状态块(){}

    // --------------------------
    // 核心功能方法
    // --------------------------
    
    // 捕获当前设备状态
    HRESULT 捕获当前状态();

    // 应用保存的状态到设备
    HRESULT 应用保存状态();

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    LPCWSTR 创建调用堆栈;
#endif
};

template<typename T原生接口, typename T关联设备接口>
class _交换链基类:public _通用基类<T原生接口, T关联设备接口> // IDirect3DSwapChain9
{
public:
    // --------------------------
    // 基础接口方法
    // --------------------------
    
    // 构造函数接管原生指针
	_交换链基类(T原生接口* p原生, T关联设备接口* p显卡): _通用基类<T原生接口, T关联设备接口>(p原生, p显卡){}
    ~_交换链基类(){}

    // --------------------------
    // 核心交换链操作
    // --------------------------
    
    // 提交画面呈现
    HRESULT 提交呈现(
        const RECT* 源区域 = nullptr,
        const RECT* 目标区域 = nullptr,
        HWND 目标窗口 = nullptr,
        const RGNDATA* 脏区域 = nullptr,
        DWORD 标志 =0
   );

    // 获取前台缓冲数据（截屏）
    HRESULT 获取前台缓冲数据(_显存表面<_交换链基类<T原生接口, T关联设备接口>, T关联设备接口>* 目标表面);

    // 获取指定后台缓冲区
    HRESULT 获取后台缓冲区(
        UINT 缓冲区索引, 
        后台缓冲类型 缓冲类型, 
        _显存表面<_交换链基类<T原生接口, T关联设备接口>, T关联设备接口>** pp输出表面
   );

    // 获取光栅器状态
    HRESULT 获取光栅状态(光栅状态* 输出状态);

    // 获取当前显示模式
    HRESULT 获取显示模式(显示模式* 输出模式);

    // 获取呈现参数配置
    HRESULT 获取呈现参数(呈现参数* 输出参数);

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    呈现参数 当前呈现参数;	// PresentParameters
    显示模式 当前显示模式;	// DisplayMode
    LPCWSTR  创建调用堆栈;	// CreationCallStack
#endif
};

template<typename T原生接口, typename T关联设备接口>
class _图形资源:public _通用基类<T原生接口, T关联设备接口> // IDirect3DResource9
{
public:
    _图形资源(T原生接口* p原生, T关联设备接口* p显卡): _通用基类<T原生接口, T关联设备接口>(p原生, p显卡){}
    ~_图形资源() {}
	
    // --------------------------
    // 通用方法实现
    // --------------------------
    HRESULT 设置私有数据(REFGUID 标识, const void* 数据, DWORD 数据大小, DWORD 标志);
    HRESULT 获取私有数据(REFGUID 标识, void* 输出数据, DWORD* 数据大小);
    HRESULT 释放私有数据(REFGUID 标识);
    DWORD 设置优先级(DWORD 新优先级);
    DWORD 获取优先级() const;
    void 预加载资源();
    资源类型 获取资源类型() const;
};

template<typename T关联设备接口>
class _顶点格式声明:public _通用基类<IDirect3DVertexDeclaration9, T关联设备接口> // IDirect3DVertexDeclaration9
{
public:
    // --------------------------
    // 基础接口方法
    // --------------------------
    _顶点格式声明(IDirect3DVertexDeclaration9* p原生, T关联设备接口* p显卡):_通用基类<IDirect3DVertexDeclaration9, T关联设备接口>(p原生, p显卡){}
    ~_顶点格式声明() {}

    // --------------------------
    // 核心功能方法
    // --------------------------
    // 获取顶点元素声明
    HRESULT 获取声明元素(
        顶点元素定义* 输出定义,
        UINT* 输出元素数量
    );

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    LPCWSTR m_创建调用堆栈;
#endif
};

template<typename T关联设备接口>
class _顶点着色器:public _通用基类<IDirect3DVertexShader9, T关联设备接口> // IDirect3DVertexShader9
{
public:
    // --------------------------
    // 基础接口方法
    // --------------------------
    _顶点着色器(IDirect3DVertexShader9* p原生, T关联设备接口* p显卡):_通用基类<IDirect3DVertexShader9, T关联设备接口>(p原生, p显卡){}
    ~_顶点着色器() {}

    // --------------------------
    // 核心功能方法
    // --------------------------
    // 获取着色器字节码
    HRESULT 获取字节码(void* 输出缓冲区, UINT* 数据大小);

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    DWORD m_着色器版本;
    LPCWSTR m_创建调用堆栈;
#endif
};

template<typename T关联设备接口>
class _像素着色器:public _通用基类<IDirect3DPixelShader9, T关联设备接口> // IDirect3DPixelShader9
{
public:
    // --------------------------
    // 基础接口方法
    // --------------------------
    _像素着色器(IDirect3DPixelShader9* p原生, T关联设备接口* p显卡):_通用基类<IDirect3DPixelShader9, T关联设备接口>(p原生, p显卡){}
    ~_像素着色器() {}

    // --------------------------
    // 核心功能方法
    // --------------------------
    
    // 获取着色器字节码
    HRESULT 获取字节码(
        void* 输出缓冲区, 
        UINT* 数据大小
    );

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    DWORD 着色器版本号;          // 原始Version
    LPCWSTR 创建调用堆栈; // 原始CreationCallStack
#endif
};

template<typename T原生接口, typename T关联设备接口>
class _基础纹理 : public _图形资源<T原生接口, T关联设备接口>  // IDirect3DBaseTexture9
{
public:
    _基础纹理(T原生接口* p原生, T关联设备接口* p显卡)
        : _图形资源<T原生接口, T关联设备接口>(p原生, p显卡) {}

    // --------------------------
    // 纹理层级管理
    // --------------------------
    DWORD 设置细节级别(DWORD 新级别);

    DWORD 获取当前细节级别() const;

    DWORD 获取Mip层级数量() const;

    // --------------------------
    // 自动Mipmap生成
    // --------------------------
    HRESULT 设置自动生成过滤方式(纹理过滤方式 过滤类型);

    纹理过滤方式 获取自动生成过滤方式() const;

    void 生成Mip子层级();

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    LPCWSTR 创建调用堆栈; // 需要手动记录创建堆栈
#endif
};

template<typename T关联设备接口>
class _平面纹理 : public _基础纹理<IDirect3DTexture9, T关联设备接口> // IDirect3DTexture9
{
public:
    _平面纹理(IDirect3DTexture9* p原生, T关联设备接口* p显卡)
        : _基础纹理<IDirect3DTexture9, T关联设备接口>(p原生, p显卡) {}

    // --------------------------
    // 精确接口方法实现
    // --------------------------
    
    // 获取层级描述
    HRESULT 获取层级描述(UINT 层级索引, 表面描述* 输出描述);

    // 获取表面层级
    HRESULT 获取表面层级(UINT 层级索引, _显存表面<_平面纹理<T关联设备接口>, T关联设备接口>** pp输出表面);

    // 锁定纹理矩形
    HRESULT 锁定矩形区域(
        UINT 层级索引,
        锁定矩形* 锁定信息,
        const RECT* 区域 = nullptr,
        DWORD 锁定标志 = 0
    );

    // 解锁纹理矩形
    HRESULT 解锁矩形区域(UINT 层级索引);

    // 标记脏矩形区域
    HRESULT 标记需更新区域(const RECT* 脏区域);

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    // 精确对应调试字段
    LPCWSTR 纹理名称;
    UINT 纹理宽度;
    UINT 纹理高度;
    UINT Mip层级数;
    DWORD 用途标志;
    像素格式 像素格式;
    资源池类型 内存池类型;
    DWORD 优先级;
    DWORD 当前细节级别;
    纹理过滤方式 过滤类型;
    UINT 锁定计数;
    LPCWSTR 创建调用堆栈;
#endif
};

template<typename T关联设备接口>
class _体积纹理 : public _基础纹理<IDirect3DVolumeTexture9, T关联设备接口> // IDirect3DVolumeTexture9
{
public:
    _体积纹理(IDirect3DVolumeTexture9* p原生, T关联设备接口* p显卡)
        : _基础纹理<IDirect3DVolumeTexture9, T关联设备接口>(p原生, p显卡) {}

    // --------------------------
    // 核心体积操作方法
    // --------------------------
    
    // 获取层级描述
    HRESULT 获取层级描述(UINT 层级索引, 体积纹理描述* 输出描述);

    // 获取体积层级
    HRESULT 获取体积层级(UINT 层级索引, _三维体积<_体积纹理<T关联设备接口>, T关联设备接口>** pp输出体积);

    // 锁定三维区域
    HRESULT 锁定三维区域(
        UINT 层级索引,
        锁定体积* 锁定信息,
        const 三维区域* 区域 = nullptr,
        DWORD 锁定标志 = 0
    );

    // 解锁三维区域
    HRESULT 解锁三维区域(UINT 层级索引);

    // 标记需更新区域
    HRESULT 标记需更新区域(const 三维区域* 脏区域);

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    // 精确对应调试字段
    LPCWSTR 纹理名称;
    UINT 纹理宽度;
    UINT 纹理高度;
    UINT 纹理深度;
    UINT Mip层级数;
    DWORD 用途标志;
    像素格式 像素格式;
    资源池类型 内存池类型;
    DWORD 优先级;
    DWORD 当前细节级别;
    纹理过滤方式 过滤类型;
    UINT 锁定计数;
    LPCWSTR 创建调用堆栈;
#endif
};

template<typename T关联设备接口>
class _立方体贴图 : public _基础纹理<IDirect3DCubeTexture9, T关联设备接口> // IDirect3DCubeTexture9
{
public:
    _立方体贴图(IDirect3DCubeTexture9* p原生, T关联设备接口* p显卡)
        : _基础纹理<IDirect3DCubeTexture9, T关联设备接口>(p原生, p显卡) {}

    // --------------------------
    // 核心立方体操作方法
    // --------------------------
    
    // 获取层级描述
    HRESULT 获取层级描述(UINT 层级索引, 表面描述* 输出描述);

    // 获取立方体表面
    HRESULT 获取立方体表面(
        立方体贴图面 面类型,
        UINT 层级索引,
        _显存表面<_立方体贴图<T关联设备接口>, T关联设备接口>** pp输出表面
    );

    // 锁定立方体面矩形区域
    HRESULT 锁定立方体面区域(
        立方体贴图面 面类型,
        UINT 层级索引,
        锁定矩形* 锁定信息,
        const RECT* 区域 = nullptr,
        DWORD 锁定标志 = 0
    );

    // 解锁立方体面区域
    HRESULT 解锁立方体面区域(
        立方体贴图面 面类型,
        UINT 层级索引
    );

    // 标记立方体面脏区域
    HRESULT 标记需更新区域(
        立方体贴图面 面类型,
        const RECT* 脏区域 = nullptr
    );

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
public:
    void 同步调试信息();
    // 精确对应调试字段
    LPCWSTR 纹理名称;
    UINT 纹理尺寸;  // _立方体贴图宽度=高度
    UINT Mip层级数;
    DWORD 用途标志;
    像素格式 像素格式;
    资源池类型 内存池类型;
    DWORD 优先级;
    DWORD 当前细节级别;
    纹理过滤方式 过滤类型;
    UINT 锁定计数;
    LPCWSTR 创建调用堆栈;
#endif
};

template<typename T关联设备接口>
class _顶点缓冲区 : public _图形资源<IDirect3DVertexBuffer9, T关联设备接口> // IDirect3DVertexBuffer9
{
public:
    _顶点缓冲区(IDirect3DVertexBuffer9* p原生, T关联设备接口* p显卡)
        : _图形资源<IDirect3DVertexBuffer9, T关联设备接口>(p原生, p显卡) {}

    // --------------------------
    // 核心顶点数据操作
    // --------------------------
    
    // 锁定顶点数据内存
    HRESULT 锁定数据(
        UINT 起始偏移,
        UINT 锁定长度,
        void** pp输出数据,
        DWORD 锁定标志 = 0
    );

    // 解锁顶点数据
    HRESULT 解锁数据();

    // 获取缓冲区描述
    HRESULT 获取缓冲区描述(顶点缓冲描述* 输出描述);

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
public:
    void 同步调试信息();
    LPCWSTR 缓冲区名称;
    UINT 数据总长度;        // 单位：字节
    DWORD 使用标志;
    DWORD 灵活顶点格式;      // 原始FVF
    资源池类型 内存池类型;
    DWORD 优先级;
    UINT 锁定次数;
    LPCWSTR 创建调用堆栈;
#endif
};

template<typename T关联设备接口>
class _索引缓冲区 : public _图形资源<IDirect3DIndexBuffer9, T关联设备接口> // IDirect3DIndexBuffer9
{
public:
    _索引缓冲区(IDirect3DIndexBuffer9* p原生, T关联设备接口* p显卡)
        : _图形资源<IDirect3DIndexBuffer9, T关联设备接口>(p原生, p显卡) {}

    // --------------------------
    // 核心索引数据操作
    // --------------------------
    
    // 锁定索引数据内存
    HRESULT 锁定数据(
        UINT 起始偏移,
        UINT 锁定长度,
        void** pp输出数据,
        DWORD 锁定标志 = 0
    );

    // 解锁索引数据
    HRESULT 解锁数据();

    // 获取缓冲区描述
    HRESULT 获取缓冲区描述(索引缓冲描述* 输出描述);

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
public:
    void 同步调试信息();
    LPCWSTR 缓冲区名称;
    UINT 数据总长度;        // 单位：字节
    DWORD 使用标志;
    像素格式 索引格式;
    资源池类型 内存池类型;
    DWORD 优先级;
    UINT 锁定次数;
    LPCWSTR 创建调用堆栈;
#endif
};

template<typename T所属容器接口, typename T关联设备接口>
class _显存表面 : public _图形资源<IDirect3DSurface9, T关联设备接口> // IDirect3DSurface9
{
private:
	using _图形资源<IDirect3DSurface9, T关联设备接口>::设置优先级;
	using _图形资源<IDirect3DSurface9, T关联设备接口>::获取优先级;
	using _图形资源<IDirect3DSurface9, T关联设备接口>::预加载资源;
	using _图形资源<IDirect3DSurface9, T关联设备接口>::获取资源类型;
    T所属容器接口* m_p所属容器; // 指向纹理或_立方体贴图
public:
    _显存表面(IDirect3DSurface9* p原生, T所属容器接口* p容器, T关联设备接口* p显卡)
        : _图形资源<IDirect3DSurface9, T关联设备接口>(p原生, p显卡), m_p所属容器(p容器) {}

    // --------------------------
    // 核心表面操作方法
    // --------------------------
    
    // 获取表面所属容器（纹理/立方体贴图等）
    HRESULT 获取所属容器(T所属容器接口** pp输出容器);

    // 获取表面描述信息
    HRESULT 获取描述信息(表面描述* 输出描述);

    // 锁定矩形区域
    HRESULT 锁定表面(
        锁定矩形* 锁定信息,
        const RECT* 区域 = nullptr,
        DWORD 锁定标志 = 0
    );

    // 解锁表面
    HRESULT 解锁表面();

    // 获取GDI设备上下文
    HRESULT 获取GDI上下文(HDC* 输出上下文);

    // 释放GDI设备上下文
    HRESULT 释放GDI上下文(HDC 上下文);

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    LPCWSTR 表面名称;
    UINT 表面宽度;
    UINT 表面高度;
    DWORD 使用用途;
    像素格式 像素格式;
    资源池类型 内存池类型;
    多重采样类型 多重采样类型;
    DWORD 采样质量;
    DWORD 优先级;
    UINT 锁定次数;
    UINT GDI使用次数;
    LPCWSTR 创建调用堆栈;
#endif
};

template<typename T所属容器接口, typename T关联设备接口>
class _三维体积 : public _图形资源<IDirect3DVolume9, T关联设备接口> // IDirect3DVolume9
{
private:
    T所属容器接口* m_p所属容器; // 指向纹理或_立方体贴图
public:
    _三维体积(IDirect3DVolume9* p原生, T所属容器接口* p容器, T关联设备接口* p显卡)
        : _图形资源<IDirect3DVolume9, T关联设备接口>(p原生, p显卡), m_p所属容器(p容器) {}

    // --------------------------
    // 核心体积操作方法
    // --------------------------
    
    // 获取所属容器（_体积纹理）
    HRESULT 获取所属容器(T所属容器接口** pp输出容器);

    // 获取体积描述信息
    HRESULT 获取描述信息(体积纹理描述* 输出描述);

    // 锁定三维区域
    HRESULT 锁定盒体(
        锁定体积* 锁定信息,
        const 三维区域* 区域 = nullptr,
        DWORD 锁定标志 = 0
    );

    // 解锁三维区域
    HRESULT 解锁盒体();

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    LPCWSTR 体积名称;
    UINT 体积宽度;
    UINT 体积高度;
    UINT 体积深度;
    DWORD 使用用途;
    像素格式 像素格式;
    资源池类型 内存池类型;
    UINT 锁定次数;
    LPCWSTR 创建调用堆栈;
#endif
};

template<typename T关联设备接口>
class _状态查询器:public _通用基类<IDirect3DQuery9, T关联设备接口> // IDirect3DQuery9
{
public:
    // --------------------------
    // 基础接口方法
    // --------------------------
    _状态查询器(IDirect3DQuery9* p原生, T关联设备接口* p显卡)
        :_通用基类<IDirect3DQuery9, T关联设备接口>(p原生, p显卡){}
    ~_状态查询器() {}

    // --------------------------
    // 核心查询功能
    // --------------------------

    查询类型 获取查询类型() const;

    DWORD 获取数据大小() const;

    // 发起查询命令（开始/结束）
    HRESULT 发起查询(DWORD 控制标志);

    // 获取查询结果
    HRESULT 获取数据(void* 输出数据, DWORD 数据大小, DWORD 获取标志);

    // --------------------------
    // 调试信息（仅调试版本）
    // --------------------------
#ifdef D3D_DEBUG_INFO
    void 同步调试信息();
    查询类型 查询类型;
    DWORD 数据尺寸;
    LPCWSTR 创建调用堆栈;
#endif
};

#define 私有数据_IUNKNOWN                     D3DSPD_IUNKNOWN

#define 创建标志_多线程                      D3DCREATE_MULTITHREADED
 
#define 创建标志_纯设备                      D3DCREATE_PUREDEVICE
#define 创建标志_软件顶点处理                D3DCREATE_SOFTWARE_VERTEXPROCESSING
#define 创建标志_硬件顶点处理                D3DCREATE_HARDWARE_VERTEXPROCESSING
#define 创建标志_混合顶点处理                D3DCREATE_MIXED_VERTEXPROCESSING
 
#define 创建标志_禁用驱动管理                D3DCREATE_DISABLE_DRIVER_MANAGEMENT
#define 创建标志_适配器组设备                D3DCREATE_ADAPTERGROUP_DEVICE
#define 创建标志_扩展禁用驱动管理            D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX
 
#define 创建标志_无窗口变化                  D3DCREATE_NOWINDOWCHANGES
 
/* D3D9Ex only -- */
#if !defined(D3D_DISABLE_9EX)
 
#define 创建标志_禁用PSGP多线程             D3DCREATE_DISABLE_PSGP_THREADING
#define 创建标志_启用呈现统计                D3DCREATE_ENABLE_PRESENTSTATS
#define 创建标志_禁用截图                    D3DCREATE_DISABLE_PRINTSCREEN
 
#define 创建标志_屏保模式                    D3DCREATE_SCREENSAVER
 
 
#endif // !D3D_DISABLE_9EX
/* -- D3D9Ex only */
 
 
 
#define 默认适配器                           D3DADAPTER_DEFAULT
 
#define 枚举标志_WHQL认证                    D3DENUM_WHQL_LEVEL
 
/* D3D9Ex only -- */
#if !defined(D3D_DISABLE_9EX)
 
#define 枚举标志_无驱动版本                  D3DENUM_NO_DRIVERVERSION
 
#endif // !D3D_DISABLE_9EX
/* -- D3D9Ex only */
 
 
#define 最大后台缓冲区数                     D3DPRESENT_BACK_BUFFERS_MAX
 
/* D3D9Ex only -- */
#if !defined(D3D_DISABLE_9EX)
 
#define 最大后台缓冲区数_EX                  D3DPRESENT_BACK_BUFFERS_MAX_EX
 
#endif // !D3D_DISABLE_9EX
/* -- D3D9Ex only */
 

#define 伽马标志_无校准                      D3DSGR_NO_CALIBRATION
#define 伽马标志_校准                        D3DSGR_CALIBRATE
 
#define 光标标志_立即更新                    D3DCURSOR_IMMEDIATE_UPDATE
 
#define 呈现标志_不等待                      D3DPRESENT_DONOTWAIT
#define 呈现标志_线性内容                    D3DPRESENT_LINEAR_CONTENT
 
/* D3D9Ex only -- */
#if !defined(D3D_DISABLE_9EX)
 
#define 呈现_不翻转                   0x00000004L
#define 呈现_翻转重启                 0x00000008L
#define 呈现_视频限制到显示器   0x00000010L
#define 呈现_仅更新覆盖层           0x00000020L
#define 呈现_隐藏覆盖层                 0x00000040L
#define 呈现_更新颜色键              0x00000080L
#define 呈现_强制立即执行              0x00000100L
 
#endif // !D3D_DISABLE_9EX
/* -- D3D9Ex only */
 
 
#define 错误_纹理格式错误                  D3DERR_WRONGTEXTUREFORMAT
#define 错误_不支持的颜色操作              D3DERR_UNSUPPORTEDCOLOROPERATION
#define 错误_不支持的颜色参数              D3DERR_UNSUPPORTEDCOLORARG
#define 错误_不支持的Alpha操作             D3DERR_UNSUPPORTEDALPHAOPERATION
#define 错误_不支持的Alpha参数             D3DERR_UNSUPPORTEDALPHAARG
#define 错误_操作过多                      D3DERR_TOOMANYOPERATIONS
#define 错误_冲突的纹理过滤                D3DERR_CONFLICTINGTEXTUREFILTER
#define 错误_不支持的因子值                D3DERR_UNSUPPORTEDFACTORVALUE
#define 错误_冲突的渲染状态                D3DERR_CONFLICTINGRENDERSTATE
#define 错误_不支持的纹理过滤              D3DERR_UNSUPPORTEDTEXTUREFILTER
#define 错误_冲突的纹理调色板              D3DERR_CONFLICTINGTEXTUREPALETTE
#define 错误_驱动内部错误                  D3DERR_DRIVERINTERNALERROR
#define 错误_未找到                        D3DERR_NOTFOUND
#define 错误_更多数据                      D3DERR_MOREDATA
#define 错误_设备丢失                      D3DERR_DEVICELOST
#define 错误_设备未重置                    D3DERR_DEVICENOTRESET
#define 错误_不可用                        D3DERR_NOTAVAILABLE
#define 错误_显存不足                      D3DERR_OUTOFVIDEOMEMORY
#define 错误_无效设备                      D3DERR_INVALIDDEVICE
#define 错误_无效调用                      D3DERR_INVALIDCALL
#define 错误_驱动无效调用                  D3DERR_DRIVERINVALIDCALL
#define 错误_仍在绘制中                    D3DERR_WASSTILLDRAWING
#define 状态_不自动生成                    D3DOK_NOAUTOGEN

// ======================
// D3D9Ex扩展接口封装
// ======================
#if !defined(D3D_DISABLE_9EX)
#define 错误_设备已移除                    D3DERR_DEVICEREMOVED
#define 状态_非驻留                        S_NOT_RESIDENT
#define 状态_驻留在共享内存                S_RESIDENT_IN_SHARED_MEMORY
#define 状态_呈现模式已更改                S_PRESENT_MODE_CHANGED
#define 状态_呈现被遮挡                    S_PRESENT_OCCLUDED
#define 错误_设备挂起                      D3DERR_DEVICEHUNG
#define 错误_不支持覆盖                    D3DERR_UNSUPPORTEDOVERLAY
#define 错误_不支持的覆盖格式              D3DERR_UNSUPPORTEDOVERLAYFORMAT
#define 错误_无法保护内容                  D3DERR_CANNOTPROTECTCONTENT
#define 错误_不支持的加密                  D3DERR_UNSUPPORTEDCRYPTO
#define 错误_呈现统计信息不连续            D3DERR_PRESENT_STATISTICS_DISJOINT


class 显卡管理器Ex:public _显卡管理器基类<IDirect3D9Ex> // IDirect3D9Ex
{
private:
	using _显卡管理器基类<IDirect3D9Ex>::获取关联设备;
public:
    显卡管理器Ex() {}
    ~显卡管理器Ex() {}

    //HRESULT 初始化(UINT SDK版本号);
    // --------------------------
    HRESULT 创建设备Ex(
        UINT 显卡索引,
        设备类型 设备类型,
        HWND 窗口句柄,
        DWORD 行为标志,
        呈现参数* 呈现参数,
        显卡设备Ex** pp输出设备接口
    );

    UINT 获取显示模式数量Ex(
        UINT 显卡索引,
        显示模式过滤器* 模式
    )const;

    HRESULT 枚举显示模式Ex(
        UINT 显卡索引,
        显示模式过滤器* 格式,
        UINT 模式索引,
        显示模式Ex* 输出模式
    );

    HRESULT 获取当前显示模式Ex(
        UINT 显卡索引,
        显示模式Ex* 输出模式
    );

    HRESULT 获取显卡LUID(
        UINT 显卡索引,
        LUID* 输出LUID
    );
};

class 显卡设备Ex:public _显卡设备基类<IDirect3DDevice9Ex, 显卡管理器Ex> // IDirect3DDevice9Ex
{
public:
    显卡设备Ex(IDirect3DDevice9Ex* p原生, 显卡管理器Ex* p显卡管理器)
        : _显卡设备基类<IDirect3DDevice9Ex, 显卡管理器Ex>(p原生, p显卡管理器) {}
    ~显卡设备Ex() {}

    HRESULT 设置单色卷积核(
        UINT 宽度,
        UINT 高度,
        float* 行系数,
        float* 列系数
    );

    HRESULT 组合矩形(
		_显存表面<void, 显卡设备Ex>* 源表面,
		_显存表面<void, 显卡设备Ex>* 目标表面,
		_顶点缓冲区<显卡设备Ex>* 源矩形数组,
		UINT 矩形数量,
		_顶点缓冲区<显卡设备Ex>* 目标位置数组,
		矩形组合操作 操作,
		int X偏移量, int Y偏移量
    );

    HRESULT 呈现画面Ex(
        const RECT* 源区域,
        const RECT* 目标区域,
        HWND 目标窗口,
        const RGNDATA* 脏区域,
        DWORD 标志
    );

    HRESULT 获取GPU线程优先级(int* 输出优先级);

    HRESULT 设置GPU线程优先级(int 新优先级);

    HRESULT 等待垂直同步(UINT 交换链索引);
    
	template<typename T资源类型>
    HRESULT 检查资源驻留(
        _基础纹理<T资源类型, 显卡设备Ex>** pp资源数组,
        UINT 资源数量
    );
    
    HRESULT 设置最大帧延迟(UINT 最大帧数);
    
    HRESULT 获取最大帧延迟(UINT* 输出最大帧数);
    
    HRESULT 检查设备状态(HWND 目标窗口句柄);
    
    HRESULT 创建渲染目标Ex(
        UINT 宽度,
        UINT 高度,
        像素格式 格式,
        多重采样类型 采样类型,
        DWORD 采样质量,
        BOOL 可锁定,
        _显存表面<void, 显卡设备Ex>** pp输出表面,
        HANDLE* 共享句柄 = nullptr,
        DWORD 使用标志 = 0
    );
    
    HRESULT 创建离屏表面Ex(
        UINT 宽度,
        UINT 高度,
        像素格式 格式,
        资源池类型 存储池,
        _显存表面<void, 显卡设备Ex>** pp输出表面,
        HANDLE* 共享句柄 = nullptr,
        DWORD 使用标志 = 0
    );
    
    HRESULT 创建深度模板表面Ex(
        UINT 宽度,
        UINT 高度,
        像素格式 格式,
        多重采样类型 采样类型,
        DWORD 采样质量,
        BOOL 自动丢弃,
        _显存表面<void, 显卡设备Ex>** 输出表面,
        HANDLE* 共享句柄 = nullptr,
        DWORD 使用标志 = 0
    );
    
    HRESULT 重置设备Ex(呈现参数* 新呈现参数, 显示模式Ex* 显示模式);
    
    HRESULT 获取显示模式Ex(UINT 交换链索引, 显示模式Ex* 显示模式, 显示旋转* 旋转信息);
};

class 交换链Ex:public _交换链基类<IDirect3DSwapChain9Ex, 显卡设备Ex> // IDirect3DSwapChain9Ex
{
public:
    交换链Ex(IDirect3DSwapChain9Ex* p原生, 显卡设备Ex* p显卡设备)
        : _交换链基类<IDirect3DSwapChain9Ex, 显卡设备Ex>(p原生, p显卡设备) {}
    // 获取最后一次呈现计数
    HRESULT 获取最后呈现计数(UINT* 输出计数);
    
    // 获取呈现统计信息
    HRESULT 获取呈现统计(呈现统计* 输出统计);
    
    // 获取扩展显示模式
    HRESULT 获取显示模式Ex(显示模式Ex* 输出模式, 显示旋转* 输出旋转);
};

class 覆盖层:public _通用基类<IDirect3D9ExOverlayExtension, void> // IDirect3D9ExOverlayExtension
{
private:
	using _通用基类<IDirect3D9ExOverlayExtension, void>::获取关联设备;
public:
    覆盖层(IDirect3D9ExOverlayExtension* p原生)
        : _通用基类<IDirect3D9ExOverlayExtension, void>(p原生, nullptr) {}
    ~覆盖层() {}
    
    HRESULT 检查设备覆盖层类型(
        UINT 显卡索引,
        设备类型 设备类型,
        UINT 覆盖层宽度,
        UINT 覆盖层高度,
        像素格式 覆盖层格式,
        显示模式Ex* 显示模式,
        显示旋转 旋转方向,
        覆盖层能力* 输出能力
    );
};

class 视频设备:public _通用基类<IDirect3DDevice9Video, void> // IDirect3DDevice9Video
{
private:
	using _通用基类<IDirect3DDevice9Video, void>::获取关联设备;
public:
    视频设备(IDirect3DDevice9Video* p原生)
        : _通用基类<IDirect3DDevice9Video, void>(p原生, nullptr) {}
    ~视频设备() {}

    HRESULT 获取内容保护能力(CONST GUID* 加密类型,CONST GUID* 解码配置,内容保护能力* 能力描述);
    HRESULT 创建认证通道(认证通道类型 通道类型,认证通道** pp输出通道,HANDLE* 通道句柄);
    HRESULT 创建加密会话(CONST GUID* 加密类型,CONST GUID* 解码配置,加密会话** pp输出会话,HANDLE* 加密句柄);
};

class 认证通道:public _通用基类<IDirect3DAuthenticatedChannel9, void> // IDirect3DAuthenticatedChannel9
{
private:
	using _通用基类<IDirect3DAuthenticatedChannel9, void>::获取关联设备;
public:
    认证通道(IDirect3DAuthenticatedChannel9* p原生)
        : _通用基类<IDirect3DAuthenticatedChannel9, void>(p原生, nullptr) {}
    ~认证通道() {}

    HRESULT 获取证书大小(UINT* 证书大小);
    HRESULT 获取证书(UINT 证书大小, BYTE* 证书数据);
    HRESULT 协商密钥交换(UINT 数据大小, VOID* 数据);
    HRESULT 查询(UINT 输入大小, CONST VOID* 输入数据, UINT 输出大小, VOID* 输出数据);
    HRESULT 配置(UINT 输入大小, CONST VOID* 输入数据, 认证通道配置输出* 输出配置);
};

class 加密会话:public _通用基类<IDirect3DCryptoSession9, void> // IDirect3DCryptoSession9
{
private:
	using _通用基类<IDirect3DCryptoSession9, void>::获取关联设备;
public:
    加密会话(IDirect3DCryptoSession9* p原生)
        : _通用基类<IDirect3DCryptoSession9, void>(p原生, nullptr) {}
    ~加密会话() {}

    HRESULT 获取证书大小(UINT* 证书大小);
    HRESULT 获取证书(UINT 证书大小, BYTE* 证书数据);
    HRESULT 协商密钥交换(UINT 数据大小, VOID* 数据);
    HRESULT 加密传输(_显存表面<加密会话, 显卡设备Ex>* 源表面, _显存表面<加密会话, 显卡设备Ex>* 目标表面, UINT 目标表面大小, VOID* 初始化向量);
    HRESULT 解密传输(_显存表面<加密会话, 显卡设备Ex>* 源表面, _显存表面<加密会话, 显卡设备Ex>* 目标表面, UINT 源表面大小, 加密块信息* 加密块信息, VOID* 内容密钥, VOID* 初始化向量);
    HRESULT 获取表面间距(_显存表面<加密会话, 显卡设备Ex>* 源表面, UINT* 表面间距);
    HRESULT 开始会话密钥刷新(VOID* 随机数, UINT 随机数大小);
    HRESULT 完成会话密钥刷新();
    HRESULT 获取加密传输密钥(VOID* 回读密钥, UINT 密钥大小);
};

#endif

// ======================
// 特殊功能接口
// ======================
//class 帮助器接口 {};         // IID_HelperName

/*
 *  创建显卡管理器对象
 *  功能：
 *    - 创建支持显卡枚举和设备创建的Direct3D核心对象
 *  参数：
 *    @开发包版本号 必须传入D3D_SDK_VERSION常量，用于验证头文件与运行库版本一致性
 */
_显卡管理器基类<IDirect3D9>* WINAPI 创建显卡管理器(UINT SDK版本);
	// 留给习惯 IDirect3D9* pd3d= Direct3DCreate9(SDK版本);形式代码的程序员。
	// 汉化版提供了如下的p管理器->初始化(SDK版本)方法，建议使用。

namespace 性能分析工具 {
   /*
    *  开始性能事件标记
    *  @颜色  事件标识颜色（D3DCOLOR格式）
    *  @名称  事件名称（支持宽字符）
    *  返回值：事件嵌套层级
    */
    inline int WINAPI 开始事件(颜色值 颜色, LPCWSTR 名称){
        return D3DPERF_BeginEvent(颜色, 名称);
    }

   /*
    *  结束当前性能事件
    *  返回值：剩余事件嵌套层级
    */
    inline int WINAPI 结束事件(){
        return D3DPERF_EndEvent();
    }

   /*
    *  设置瞬时性能标记
    *  @颜色  标记颜色
    *  @名称  标记说明文字
    */
    inline void WINAPI 设置标记(颜色值 颜色, LPCWSTR 名称){
        D3DPERF_SetMarker(颜色, 名称);
    }

   /*
    *  设置持续性能区域
    *  @颜色  区域标识颜色
    *  @名称  区域说明文字
    */
    inline void WINAPI 设置区域(颜色值 颜色, LPCWSTR 名称){
        D3DPERF_SetRegion(颜色, 名称);
    }

   /*
    *  检测是否处于重复帧捕获模式
    *  返回值：TRUE表示工具正在捕获重复帧
    */
    inline BOOL WINAPI 检测重复帧模式(){
        return D3DPERF_QueryRepeatFrame();
    }

   /*
    *  配置性能分析选项
    *  @选项标志位 可组合使用：
    *    D3DPERF_选项_禁用_参数校验
    *    D3DPERF_选项_启用_实时分析
    */
    inline void WINAPI 设置选项(DWORD 选项标志位){
        D3DPERF_SetOptions(选项标志位);
    }

   /*
    *  获取当前分析器状态
    *  返回值包含以下状态位：
    *    D3DPERF_状态_正在捕获帧
    *    D3DPERF_状态_性能警告
    */
    inline DWORD WINAPI 获取状态(){
        return D3DPERF_GetStatus();
    }
}; // namespace 性能分析工具

HRESULT WINAPI 创建显卡管理器Ex(
    UINT SDK版本,
    显卡管理器Ex** pp输出管理器
);

#endif /* _D3D9ZHONGWEN_H_ABCDE_*/
